package com.powernode.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.powernode.domain.Prod;
import com.powernode.domain.ProdTagReference;
import com.powernode.domain.Sku;
import com.powernode.mapper.ProdMapper;
import com.powernode.mapper.ProdTagReferenceMapper;
import com.powernode.mapper.SkuMapper;
import com.powernode.service.ProdService;
import com.powernode.service.ProdTagReferenceService;
import com.powernode.service.SkuService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class ProdServiceImpl extends ServiceImpl<ProdMapper, Prod> implements ProdService {
    @Autowired
    private ProdMapper prodMapper;
    @Autowired
    private ProdTagReferenceService prodTagReferenceService;
    @Autowired
    private SkuService skuService;
    @Autowired
    private ProdTagReferenceMapper prodTagReferenceMapper;
    @Autowired
    private SkuMapper skuMapper;
    /*
     * 新增商品
     * @author RenBoQing
     * @date 2024/7/28 14:08
     * @param product
     * @return boolean
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean saveProduct(Prod product) {
        // 新增商品
        product.setShopId(1L);
        product.setSoldNum(0);
        product.setCreateTime(new Date());
        product.setUpdateTime(new Date());
        product.setVersion(0);
        Prod.DeliveryModeVo deliveryModeVo = product.getDeliveryModeVo();
        product.setDeliveryMode(JSONObject.toJSONString(deliveryModeVo));
        int insert = prodMapper.insert(product);
        if (insert > 0) {
            // 处理商品和分组标签的关系
            // 获取当前商品 分组的标签
            List<Long> tagList = product.getTagList();
            // 创建商品与分组标的关系集合
            List<ProdTagReference> prodTagReferenceList = new ArrayList<>();
            // 判断是否有分组标签
            if (tagList != null && tagList.size() > 0) {
                // 循环遍历分组标签 id的集合
                tagList.forEach(tagId -> {
                    ProdTagReference prodTagReference = new ProdTagReference();
                    prodTagReference.setProdId(product.getProdId());
                    prodTagReference.setTagId(tagId);
                    prodTagReference.setCreateTime(new Date());
                    prodTagReference.setShopId(1L);
                    prodTagReferenceList.add(prodTagReference);
                });
            }
            // 批量新增商品和分组标签的关系
            prodTagReferenceService.saveBatch(prodTagReferenceList);
            // 处理 商品和商品的sku的关系
            // 获取商品sku集合
            List<Sku> skuList = product.getSkuList();
            if (skuList != null && skuList.size() > 0) {
                //创建sku集合与商品关系集合
                // 循环遍历sku集合
                skuList.forEach(sku -> {
                    sku.setProdId(product.getProdId());
                    sku.setProdName(product.getProdName());
                    sku.setCreateTime(new Date());
                    sku.setUpdateTime(new Date());
                    sku.setVersion(1);
                    sku.setStatus(1);
                    sku.setActualStocks(sku.getStocks());
                });
                skuService.saveBatch(skuList);
            }
        }

        return insert > 0;
    }

    /*
     * 根据id查询商品的详情
     * @author RenBoQing
     * @date 2024/7/28 14:46
     * @param prodId
     * @return com.powernode.domain.Prod
     */
    @Override
    public Prod queryProductInfoByProId(Long prodId) {
        // 查询商品详情
        Prod prod = prodMapper.selectById(prodId);
        // 查询商品和分组标签的关系
        List<ProdTagReference> prodTagReferenceList = prodTagReferenceMapper.selectList(new LambdaQueryWrapper<ProdTagReference>()
                .eq(ProdTagReference::getProdId, prodId));
        // 判断是否有值
        if (CollectionUtils.isNotEmpty(prodTagReferenceList) && prodTagReferenceList.size() > 0) {
            // 创建商品和分组标签的集合  获取对应的id集合
            List<Long> tagIdList = prodTagReferenceList.stream().map(ProdTagReference::getTagId).collect(Collectors.toList());
            // 设置对应的值
            prod.setTagList(tagIdList);
        }
        // 根据商品id查询sku对象集合
        List<Sku> skuList = skuMapper.selectList(new LambdaQueryWrapper<Sku>().eq(Sku::getProdId, prodId));
        if (CollectionUtils.isNotEmpty(skuList) && skuList.size() > 0) {
            // 设置对应的值
            prod.setSkuList(skuList);
        }
        return prod;
    }

    /*
     *  修改商品信息
     * @author RenBoQing
     * @date 2024/7/28 15:21
     * @param product
     * @return boolean
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updateProductById(Prod product) {
        //删除商品和分组标签的关系
        prodTagReferenceMapper.delete(new LambdaQueryWrapper<ProdTagReference>().eq(ProdTagReference::getProdId, product.getProdId()));
        // 重新新增商品和分组标签的关系
        // 处理商品和分组标签的关系
        // 获取当前商品 分组的标签
        List<Long> tagList = product.getTagList();
        // 创建商品与分组标的关系集合
        List<ProdTagReference> prodTagReferenceList = new ArrayList<>();
        // 判断是否有分组标签
        if (tagList != null && tagList.size() > 0) {
            // 循环遍历分组标签 id的集合
            tagList.forEach(tagId -> {
                ProdTagReference prodTagReference = new ProdTagReference();
                prodTagReference.setProdId(product.getProdId());
                prodTagReference.setTagId(tagId);
                prodTagReference.setCreateTime(new Date());
                prodTagReference.setShopId(1L);
                prodTagReferenceList.add(prodTagReference);
            });
        }
        // 批量新增商品和分组标签的关系
        prodTagReferenceService.saveBatch(prodTagReferenceList);
        //  获取商品sku集合
        List<Sku> skuList = product.getSkuList();
        if (CollectionUtils.isNotEmpty(skuList) && skuList.size() > 0) {
            skuList.forEach(sku -> {
                sku.setUpdateTime(new Date());
                sku.setActualStocks(sku.getStocks());
            });
            // 更新对应的关系
            skuService.updateBatchById(skuList);
        }
        // 修改商品信息
        product.setUpdateTime(new Date());
        return prodMapper.updateById(product) > 0;
    }

    /*
     * 删除商品信息
     * @author RenBoQing
     * @date 2024/7/28 16:06
     * @param prodId
     * @return boolean
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean removeProdById(Long prodId) {
        //删除商品和分组标签的关系
        prodTagReferenceMapper.delete(new LambdaQueryWrapper<ProdTagReference>().eq(ProdTagReference::getProdId, prodId));
        // 根据商品id删除sku信息
        skuMapper.delete(new LambdaQueryWrapper<Sku>().eq(Sku::getProdId, prodId));
        // 删除商品信息
        return prodMapper.deleteById(prodId) > 0;
    }
}